{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Error mitigation tutorial\n", "\n", "The purpose of this tutorial is to demonstrate the basic use of error mitigation routines of the QREM package." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from qrem.cn import simulation as cnsimulation \n", "from qrem.mitigation import mitigation_routines\n", "from qrem.benchmarks import hamiltonians\n", "from qrem.characterization import characterization_routine\n", "from datetime import date\n", "from qrem.providers import simulation as simulate_experiment\n", "from qrem.qtypes.characterization_data import CharacterizationData\n", "from qrem.qtypes.mitigation_data import MitigationData\n", "from qrem.visualisation import benchmark_plots_functions" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### List of contents \n", "\n", "\n", "1. [Data generation for mitigation routine](#Part1)\n", "\n", " 1.1 [Creation and execution of the experiments on simulators/real quantum hardware](#Part1)\n", " \n", " 1.2. [Execution of the characterization routine](#Characterization)\n", "\n", "2. [Mitigation workflow](#Mitigation)\n", "\n", " 2.1 [Initial steps](#InitialS)\n", "\n", " 2.2 [Error mitigation execution](#MExecution)\n", "\n", " 2.3 [Performance analysis](#PAnalysis)\n", "\n", " 2.4 [Visualization](#Visualization)\n", "\n", "\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### 1.1.1 Preparation of experiments characterizing readout noise\n", "\n", "The first step in experiment preparation is creation of characterization circuits. \n", "This requires specifying the following parameters: \n", "\n", "1. number_of_qubits - a variable describing number of qubits for which characterization is going to be performed. Note that number_of_qubits is not necessarily equal to the total numbers of qubits in a device, as one may be interested in characterization only a subset of all qubits. In the example below we set number of qubits to 10\n", "\n", "2. experiment_name - a string specifying a typ of readout characterization experiment to be performed. QREM supports two types of characterization experiments Quantum Detector Overlapping Tomography ('QDOT') or Diagonal Detector Overlapping Tomography ('DDOT'). Here we choose 'DDOT'. \n", "\n", "3. Number of characterization circuits: number of circuits used in characterization routine.\n", "\n", "4. Number of shots (number of each circuits repetition).\n", "\n", "5. include_benchmark_circuits - a bool variable indicating whether the experiment should include circuits that are going to be used in noise model reconstruction and mitigation benchmarks .\n", "\n", "6. number_of_benchmark_circuits - an integer specifying number of circuits used in benchmarks. \n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "number_of_qubits = 10\n", "\n", "experiment_type = \"DDOT\"\n", "\n", "number_of_circuits = 300\n", "\n", "number_of_shots = 10**4\n", "\n", "include_benchmark_circuits = True\n", "\n", "number_of_benchmark_circuits = 20\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### 1.1.2 Execution of the experiments on simulators/real quantum hardware\n", "\n", "Execution of characterization circuits on quantum backends requires access to quantum hardware. QREM supports backends such as IBM Quantum and AWS Bracket. Detailed description of circuits implementation on those backends is described in tutorials .\n", "\n", "To illustrate functionalities of the package here we simulate a noise characterization experiment according to a CN noise model (see). For simplicity we do not include neighbors.\n", "\n", "To specify the noise model one needs to provide number of clusters of given locality:\n", "\n", "1. number_of_3_qubit_clusters - number of clusters of locality 3 (consisting of 3 qubits) Here set to 1.\n", "\n", "2. number_of_2_qubit_clusters - number of clusters of locality 2 (consisting of 2 qubits) Here set to 3.\n", "\n", "3. number_of_1_qubit_clusters - number of clusters of locality 1 (consisting of 3 qubits) Here set to 1.\n", "\n", "The noise model is created using cn.simulation module. It returns object of a CNNoiseModel class that stores all properties of the CN nosie model. \n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "number_of_3_qubit_clusters = 1\n", "\n", "number_of_2_qubit_clusters = 3\n", "\n", "number_of_1_qubit_clusters = 1\n", "\n", "noise_model_simulation=cnsimulation.create_random_noise_model(number_of_qubits=number_of_qubits,clusters_specification=[[3,number_of_3_qubit_clusters], [2, number_of_2_qubit_clusters], [1, number_of_1_qubit_clusters]])\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "An object of CharacterizationData class is created, which stores all data created during characterization stage, and benchmark circuits corresponding to ground states of local Hamiltonians are created. \n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "characterization_data_container = CharacterizationData()\n", "\n", "characterization_data_container.experiment_type = 'DDOT' \n", "\n", "if include_benchmark_circuits:\n", " \n", " hamiltonians_dictionary, circuits_ground_states = hamiltonians.create_hamiltonians_and_ground_states(number_of_qubits=number_of_qubits,number_of_benchmark_circuits=number_of_benchmark_circuits)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Simulation of the noisy experiment is performed using simulate_noisy_experiment function that requires the following parameters:\n", "\n", "1. noise_model - an object of CNNoiseModel class, here noise_model_simulation.\n", "\n", "2. number_of_circuits - an integer specifying number of circuits used in characterization. Here number_of_circuits set in preparation stage.\n", "\n", "3. number_of_shots - an integer specifying number of shots. Here number_of_shots set in preparation stage.\n", "\n", "Results of experiment are stored in the characterization_data_container object." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "WARNING: Possible count of random circuits (300) is lower than desired total circuit count (1315).\n", "10\n", "completeness: True\n", "Adding 290 random circuits to a 10-element set\n", "Set of 300 circuits, completeness: True\n", "noisy results generated in: 13.611753463745117 seconds\n", "\u001b[36m\u001b[1mSaving pickled file to: \u001b[0m '.'\n", "\u001b[36m\u001b[1mSaving pickled file to: \u001b[0m '.'\n" ] } ], "source": [ "characterization_data_container.results_dictionary = simulate_experiment.simulate_noisy_experiment(noise_model=noise_model_simulation,number_of_circuits=number_of_circuits,number_of_shots=number_of_shots,save_data=True,new_data_format=True,ground_states_circuits=circuits_ground_states,data_directory='').counts\n", "\n", "characterization_data_container.ground_states_list = list(characterization_data_container.results_dictionary.keys())[-number_of_benchmark_circuits:]" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### Execution of the characterization routine\n", "\n", "Execution of the characterization routine is performed. Function execute_characterization_workflow takes as an input experimental data stored in characterization_data_container object. Detailed description of the noise characterization functionalities can be found in tutorial 2 Noise Characterisation \n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[36m\u001b[1mMARGINALS COMPUTATION FINISHED\u001b[0m\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 55/55 [00:00<00:00, 3250.12it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\u001b[36m\u001b[1mREDUCED POVMS COMPUTATION FINISHED\u001b[0m\n", "\u001b[31m\u001b[1m\n", "Calculating errors of type:\u001b[0m ('worst_case', 'classical')\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 10/10 [00:00<00:00, 16723.70it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\u001b[36m\u001b[1mDONE\u001b[0m\n", "\u001b[36m\u001b[1mPOVMS DISTANCES COMPUTATION FINISHED\u001b[0m\n", "\u001b[31m\u001b[1m\n", "Calculating correlations of type:\u001b[0m ('worst_case', 'classical')\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 45/45 [00:00<00:00, 3199.91it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\u001b[36m\u001b[1mDONE\u001b[0m\n", "\u001b[36m\u001b[1mPAIRWISE READOUT ERRORS CORRELATION COEFFICIENTS FINISHED\u001b[0m\n", "\u001b[31m\u001b[1m\n", "Current max cluster size:\u001b[0m 2\n", "\u001b[31m\u001b[1m\n", "Current max cluster size:\u001b[0m 3\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\u001b[31m\u001b[1m\n", "Current max cluster size:\u001b[0m 4\n" ] } ], "source": [ "characterization_data_container= characterization_routine.execute_characterization_workflow(characterization_data_container=characterization_data_container)\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "\n", "### Readout error mitigation \n", "\n", "To demonstrate functionalities of mitigation module \n", "\n", "One of the results of the characterization workflow are reconstructed noise models of different locality. To demonstrate functionalities of mitigation results of error mitigation based on those models are compared to the exact noise model that was used in the simulation of the noisy experiment. \n", "To this end characterization_data_container is updated to include the exact noise model. This is an optional step and it is not performed when working with data coming from quantum hardware. \n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "characterization_data_container.noise_model_list.append(noise_model_simulation) " ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### 2.1 Initial steps \n", "\n", "Energy of ground states prepared by the noisy device is estimated \n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "20it [00:00, 2221.09it/s]\n" ] } ], "source": [ "energy_dictionary= hamiltonians.eigenstate_energy_calculation_and_estimation(characterization_data_container.benchmark_results_dictionary , characterization_data_container.benchmark_marginals_dictionary ,hamiltonians_dictionary)\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "An object of MitigationData class is created to store results of mitigation is created\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "mitigation_data = MitigationData()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### 2.2 Error mitigation execution\n", "\n", "Error mitigation is performed using estimate_mitigated_energy_over_noise_models function of the mitigation module. It performs mitigation for all CN noise models reconstructed during the characterization stage. For each noise model it returns a dictionary with the mitigated values of energies for Hamiltonians used in the benchmark. The corresponding data structure is a dictionary. As an input to the mitigation routine one need to specify:\n", "\n", "1. characterization_data- an object of CharacterizationData class storing results of characterization routine and experimental data, here characterization_data_container \n", "\n", "2. hamiltonians_dictionary - dictionary specifying Hamiltonians, for which ground states were implemented, here hamiltonians_dictionary\n", "\n", " " ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 20/20 [00:00<00:00, 249.40it/s]\n", "100%|██████████| 20/20 [00:00<00:00, 267.84it/s]\n", "100%|██████████| 20/20 [00:00<00:00, 206.93it/s]\n", "100%|██████████| 20/20 [00:00<00:00, 246.86it/s]\n" ] } ], "source": [ "\n", "noise_models_mitigation_results_dictionary = mitigation_routines.estimate_mitigated_energy_over_noise_models(characterization_data=characterization_data_container ,hamiltonians_dictionary=hamiltonians_dictionary,return_marginals=True)\n", "\n", " \n", "mitigation_data.noise_models_mitigation_results_dictionary = noise_models_mitigation_results_dictionary " ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### 2.4 Performance analysis\n", "\n", "To compute errors of mitigation the exact data is compared to results obtained using error mitigation. Also some statistical features of the errors for different noise models are obtained and printed together with the corresponding clusters structure. The last results correspond to the noise model used in characterization experiment simulation\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[36m\u001b[1m((0,), (1,), (2,), (3,), (4,), (5,), (6,), (7,), (8,), (9,))\u001b[0m\n", "\u001b[36m\u001b[1mMitigation error mean\u001b[0m 0.5767024938191828\n", "\u001b[36m\u001b[1mMitigation error median\u001b[0m 0.38284537497778737\n", "\u001b[36m\u001b[1m((0, 3), (5, 9), (7, 8), (1, 4), (2, 6))\u001b[0m\n", "\u001b[36m\u001b[1mMitigation error mean\u001b[0m 0.22468234094681996\n", "\u001b[36m\u001b[1mMitigation error median\u001b[0m 0.16051428372192794\n", "\u001b[36m\u001b[1m((0, 2, 3), (5, 6, 9), (7, 8), (1, 4))\u001b[0m\n", "\u001b[36m\u001b[1mMitigation error mean\u001b[0m 0.07579283566475507\n", "\u001b[36m\u001b[1mMitigation error median\u001b[0m 0.053939441867717264\n", "\u001b[36m\u001b[1m((5, 6, 9), (1, 4), (7, 8), (0, 3), (2,))\u001b[0m\n", "\u001b[36m\u001b[1mMitigation error mean\u001b[0m 0.07181963262818221\n", "\u001b[36m\u001b[1mMitigation error median\u001b[0m 0.05476190095380651\n" ] } ], "source": [ "noise_models_mitigated_energy_dictionary_error = mitigation_routines.compute_mitigation_errors(mitigation_data=mitigation_data,hamiltonian_energy_dictionary=energy_dictionary,number_of_qubits=number_of_qubits)\n", "\n", "mitigation_data.noise_models_mitigated_energy_dictionary_error = noise_models_mitigated_energy_dictionary_error \n", "\n", "noise_models_mitigated_energy_dictionary_error_statistics= mitigation_routines.compute_mitigation_error_median_mean(mitigation_data=mitigation_data, print_results=True)\n", "\n", "mitigation_data.noise_models_mitigated_energy_dictionary_error_statistics = noise_models_mitigated_energy_dictionary_error_statistics" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### 2.4 Visualization\n", "\n", "Errors of mitigation procedure are visualized on a histogram " ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "benchmark_plots_functions.create_error_mitigation_histogram(mitigation_data=mitigation_data,energy_dictionary=energy_dictionary,number_of_qubits=number_of_qubits)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "venv_dev", "language": "python", "name": "venv_dev" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.11" }, "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2 }